#ifndef VEC2_H
#define VEC2_H

template <class T>
class Vec2
{
public:
    Vec2() : m_x(0), m_y(0) {}
    Vec2(T x, T y) : m_x(x), m_y(y) {}

    T X() const { return m_x; }
    T Y() const { return m_y; }
    void SetX(T x) { m_x = x; }
    void SetY(T y) { m_y = y; }

	void invert()
	{
		m_x = -m_x;
		m_y = -m_y;
	}


    Vec2& operator+=(const Vec2& rhs)
    {
        m_x += rhs.m_x;
        m_y += rhs.m_y;
        return *this;
    }

    Vec2& operator-=(const Vec2& rhs)
    {
        m_x -= rhs.m_x;
        m_y -= rhs.m_y;
        return *this;
    }

    Vec2& operator*=(T f)
    {
        m_x *= f;
        m_y *= f;
        return *this;
    }
	Vec2& operator<=(const Vec2& rhs)
	{
		if ((m_x <= rhs.m_x) && (m_y <= rhs.m_y))
		{
			return true;
		}
		else 
		{
			return false;
		}
	}
	Vec2& operator>=(const Vec2& rhs)
	{
		if ((m_x >= rhs.m_x) && (m_y >= rhs.m_y))
		{
			return true;
		}
		else 
		{
			return false;
		}
    }

private:
    T m_x, m_y;
};

template <class T>
Vec2<T> operator+(const Vec2<T>& a, const Vec2<T>& b)
{
    Vec2<T> res = a;
    res += b;
    return res;
}

template <class T>
Vec2<T> operator-(const Vec2<T>& a, const Vec2<T>& b)
{
    Vec2<T> res = a;
    res -= b;
    return res;
}

template <class T>
Vec2<T> operator*(const Vec2<T>&a, T f)
{
    Vec2<T> res = a;
    res *= f;
    return res;
}
template <class T>
bool operator<(const Vec2<T>& a, const Vec2<T>& b)
{
	if ((a.m_x < b.m_x) && (a.m_y < b.m_y))
	{
		return true;
	}
	else 
	{
		return false;
	}

}
template <class T>
bool operator>(const Vec2<T>& a, const Vec2<T>& b)
{
	if ((a.m_x > b.m_x) && (a.m_y > b.m_y))
	{
		return true;
	}
	else 
	{
		return false;
	}

}

typedef Vec2<float> Vec2f;
typedef Vec2<int> Vec2i;

#endif